const User = require('../models/user.js');
const { hashPassword, comparePassword } = require('../utils/auth');
const { validateUser, validateUpdateUser } = require('../utils/validators');

/**
 * 用户业务组件
 * 封装用户相关的业务逻辑和数据处理
 */
class UserComponent {
  
  /**
   * 创建新用户
   * @param {Object} userData 用户数据
   * @returns {Promise<Object>} 操作结果
   */
  static async createUser(userData) {
    try {
      // 数据验证
      const { error, value } = validateUser(userData);
      if (error) {
        return {
          success: false,
          message: '数据验证失败',
          errors: error.details.map(detail => detail.message)
        };
      }

      // 检查用户名是否已存在
      const existingUser = await User.isUsernameExists(value.username);
      if (existingUser) {
        return {
          success: false,
          message: '用户名已存在'
        };
      }

      // 密码加密
      const hashedPassword = await hashPassword(value.password);
      
      // 创建用户
      const newUser = await User.create({
        ...value,
        password: hashedPassword
      });

      if (newUser) {
        return {
          success: true,
          message: '用户创建成功',
          data: newUser.toJSON()
        };
      } else {
        return {
          success: false,
          message: '用户创建失败'
        };
      }
    } catch (error) {
      console.error('UserComponent.createUser 错误:', error);
      return {
        success: false,
        message: '创建用户时发生错误',
        error: error.message
      };
    }
  }

  /**
   * 获取用户列表
   * @param {Object} options 查询选项
   * @returns {Promise<Object>} 操作结果
   */
  static async getUserList(options = {}) {
    try {
      const {
        page = 1,
        limit = 10,
        username,
        role
      } = options;

      const filters = {};
      if (username) filters.username = username;
      if (role) filters.role = role;

      
      
      const result = await User.findAll(page, limit, filters);

      return {
        success: true,
        message: '获取用户列表成功',
        data: result.data.map(user => user.toJSON()),
        pagination: result.pagination
      };
    } catch (error) {
      console.error('UserComponent.getUserList 错误:', error);
      return {
        success: false,
        message: '获取用户列表时发生错误',
        error: error.message
      };
    }
  }

  /**
   * 根据ID获取用户
   * @param {number} userId 用户ID
   * @returns {Promise<Object>} 操作结果
   */
  static async getUserById(userId) {
    try {
      if (!userId || isNaN(userId)) {
        return {
          success: false,
          message: '无效的用户ID'
        };
      }

      const user = await User.findById(userId);
      if (!user) {
        return {
          success: false,
          message: '用户不存在'
        };
      }

      return {
        success: true,
        message: '获取用户信息成功',
        data: user.toJSON()
      };
    } catch (error) {
      console.error('UserComponent.getUserById 错误:', error);
      return {
        success: false,
        message: '获取用户信息时发生错误',
        error: error.message
      };
    }
  }

  /**
   * 更新用户信息
   * @param {number} userId 用户ID
   * @param {Object} updateData 更新数据
   * @returns {Promise<Object>} 操作结果
   */
  static async updateUser(userId, updateData) {
    try {
      if (!userId || isNaN(userId)) {
        return {
          success: false,
          message: '无效的用户ID'
        };
      }

      // 数据验证
      const { error, value } = validateUpdateUser(updateData);
      if (error) {
        return {
          success: false,
          message: '数据验证失败',
          errors: error.details.map(detail => detail.message)
        };
      }

      // 检查用户是否存在
      const existingUser = await User.findById(userId);
      if (!existingUser) {
        return {
          success: false,
          message: '用户不存在'
        };
      }

      // 如果更新用户名，检查是否重复
      if (value.username && value.username !== existingUser.username) {
        const isExists = await User.isUsernameExists(value.username, userId);
        if (isExists) {
          return {
            success: false,
            message: '用户名已存在'
          };
        }
      }

      // 如果更新密码，进行加密
      if (value.password) {
        value.password = await hashPassword(value.password);
      }

      // 更新用户
      const updatedUser = await User.updateById(userId, value);
      if (updatedUser) {
        return {
          success: true,
          message: '用户更新成功',
          data: updatedUser.toJSON()
        };
      } else {
        return {
          success: false,
          message: '用户更新失败'
        };
      }
    } catch (error) {
      console.error('UserComponent.updateUser 错误:', error);
      return {
        success: false,
        message: '更新用户时发生错误',
        error: error.message
      };
    }
  }

  /**
   * 删除用户
   * @param {number} userId 用户ID
   * @returns {Promise<Object>} 操作结果
   */
  static async deleteUser(userId) {
    try {
      if (!userId || isNaN(userId)) {
        return {
          success: false,
          message: '无效的用户ID'
        };
      }

      // 检查用户是否存在
      const existingUser = await User.findById(userId);
      if (!existingUser) {
        return {
          success: false,
          message: '用户不存在'
        };
      }

      const deleted = await User.deleteById(userId);
      if (deleted) {
        return {
          success: true,
          message: '用户删除成功'
        };
      } else {
        return {
          success: false,
          message: '用户删除失败'
        };
      }
    } catch (error) {
      console.error('UserComponent.deleteUser 错误:', error);
      return {
        success: false,
        message: '删除用户时发生错误',
        error: error.message
      };
    }
  }

  /**
   * 批量删除用户
   * @param {Array} userIds 用户ID数组
   * @returns {Promise<Object>} 操作结果
   */
  static async batchDeleteUsers(userIds) {
    try {
      if (!Array.isArray(userIds) || userIds.length === 0) {
        return {
          success: false,
          message: '请提供要删除的用户ID数组'
        };
      }

      // 验证所有ID都是数字
      const validIds = userIds.filter(id => !isNaN(id));
      if (validIds.length !== userIds.length) {
        return {
          success: false,
          message: '存在无效的用户ID'
        };
      }

      const deletedCount = await User.deleteByIds(validIds);
      
      return {
        success: true,
        message: `成功删除 ${deletedCount} 个用户`,
        deletedCount
      };
    } catch (error) {
      console.error('UserComponent.batchDeleteUsers 错误:', error);
      return {
        success: false,
        message: '批量删除用户时发生错误',
        error: error.message
      };
    }
  }

  /**
   * 用户登录验证
   * @param {string} username 用户名
   * @param {string} password 密码
   * @returns {Promise<Object>} 操作结果
   */
  static async authenticateUser(username, password) {
    try {
      if (!username || !password) {
        return {
          success: false,
          message: '用户名和密码不能为空'
        };
      }

      // 查找用户
      const user = await User.findByUsername(username);
      if (!user) {
        return {
          success: false,
          message: '用户名或密码错误'
        };
      }

      // 验证密码
      const isValidPassword = await comparePassword(password, user.password);
      if (!isValidPassword) {
        return {
          success: false,
          message: '用户名或密码错误'
        };
      }

      // 更新最后登录时间
      await User.updateLastLogin(user.id);

      return {
        success: true,
        message: '登录成功',
        data: user.toJSON()
      };
    } catch (error) {
      console.error('UserComponent.authenticateUser 错误:', error);
      return {
        success: false,
        message: '登录验证时发生错误',
        error: error.message
      };
    }
  }

  /**
   * 检查用户权限
   * @param {number} userId 用户ID
   * @param {string} requiredRole 所需角色
   * @returns {Promise<Object>} 操作结果
   */
  static async checkUserPermission(userId, requiredRole) {
    try {
      const user = await User.findById(userId);
      if (!user) {
        return {
          success: false,
          message: '用户不存在'
        };
      }

      const roleHierarchy = {
        'user': 1,
        'manager': 2,
        'admin': 3
      };

      const userLevel = roleHierarchy[user.role] || 0;
      const requiredLevel = roleHierarchy[requiredRole] || 0;

      if (userLevel >= requiredLevel) {
        return {
          success: true,
          message: '权限验证通过',
          data: { user: user.toJSON(), hasPermission: true }
        };
      } else {
        return {
          success: false,
          message: '权限不足',
          data: { user: user.toJSON(), hasPermission: false }
        };
      }
    } catch (error) {
      console.error('UserComponent.checkUserPermission 错误:', error);
      return {
        success: false,
        message: '权限检查时发生错误',
        error: error.message
      };
    }
  }
}

module.exports = UserComponent; 